JavaScript Using Declaration Async: Zamonaviy ilovalar uchun asinxron resurslarni boshqarish

Zamonaviy JavaScript dasturlashda, ayniqsa Node.js va murakkab front-end ilovalarida, resurslarni samarali boshqarish juda muhim. Ishlatilgandan so'ng resurslarni to'g'ri bo'shatmaslik xotira sizib chiqishiga, unumdorlikning pasayishiga va natijada ilovaning beqarorligiga olib kelishi mumkin. 'using' deklaratsiyasi, ayniqsa asinxron yo'q qilinadiganlar bilan birgalikda, asinxron JavaScript muhitlarida resurslarni xavfsiz va ishonchli boshqarish uchun kuchli mexanizmni taqdim etadi.

Asinxron resurslarni boshqarish zaruratini tushunish

JavaScript'ning hodisalarga asoslangan, bloklanmaydigan tabiati uni asinxron operatsiyalarni boshqarish uchun ideal qiladi. Biroq, bu asinxronlik resurslarni boshqarishda qiyinchiliklarni keltirib chiqaradi. An'anaviy sinxron resurslarni boshqarish usullari, masalan, try-finally bloklari, asinxron tozalashni talab qiladigan resurslar bilan ishlashda unchalik samarali bo'lmaydi. Ma'lumotlar bazasi bilan o'zaro aloqada bo'lish, ma'lumotlarni qayta ishlash va keyin ulanishni yopish kerak bo'lgan stsenariyni tasavvur qiling. Agar ma'lumotlar bazasi ulanishini yopish asinxron bo'lsa, oddiy try-finally bloki barcha holatlarda, ayniqsa asinxron yopish jarayonida istisnolar yuzaga kelsa, to'g'ri tozalashni kafolatlamasligi mumkin.

Asinxron resurslarni boshqarish muhim bo'lgan ushbu keng tarqalgan stsenariylarni ko'rib chiqing:

• Ma'lumotlar bazasi ulanishlari: Ma'lumotlar bazalariga (masalan, PostgreSQL, MongoDB, MySQL) asinxron tarzda ulanishlarni ochish va yopish.
• Fayl oqimlari: Fayllardan o'qish va yozish, xatolar yuzaga kelganda ham oqimlarning to'g'ri yopilishini ta'minlash.
• Tarmoq soketlari: Serverlar yoki API'lar bilan aloqa qilish uchun tarmoq ulanishlarini o'rnatish va yopish.
• Tashqi xizmatlar: Asinxron ishga tushirish va tozalash tartib-qoidalarini talab qiladigan tashqi xizmatlar bilan o'zaro aloqada bo'lish.
• WebSockets: Doimiy WebSocket ulanishlarini boshqarish.

To'g'ri boshqaruvsiz bu resurslar to'planib, resurslarning tugashiga va ilovalarning ishdan chiqishiga olib kelishi mumkin. 'using' deklaratsiyasi, asinxron yo'q qilinadiganlar bilan birgalikda, bu muammoga mustahkam yechim taklif qiladi.

'using' deklaratsiyasi bilan tanishuv

'using' deklaratsiyasi resurslar endi kerak bo'lmaganda avtomatik ravishda yo'q qilinishini ta'minlashning deklarativ usulini taqdim etadi. U Disposable yoki AsyncDisposable interfeysini amalga oshiradigan obyektlar bilan ishlash uchun mo'ljallangan. O'zgaruvchi 'using' bilan e'lon qilinganda, o'zgaruvchi e'lon qilingan blokdan chiqilganda obyektning dispose() yoki [Symbol.asyncDispose]() usuli avtomatik ravishda chaqiriladi, chiqishning normal yakunlanishi, istisno yoki return yoki break kabi boshqaruv operatori tufayli bo'lishidan qat'i nazar.

Sinxron yo'q qilinadiganlar

Sinxron yo'q qilinadiganlar uchun obyekt dispose() usulini talab qiluvchi Disposable interfeysini amalga oshirishi kerak. Mana oddiy misol:

            class MyResource {
  constructor() {
    console.log("Resource acquired");
  }

  dispose() {
    console.log("Resource disposed");
  }
}

{
  using resource = new MyResource();
  console.log("Using the resource");
}

// Output:
// Resource acquired
// Using the resource
// Resource disposed

            

              
                Copy
              
            
          

Bu misolda, 'using' deklaratsiyasini o'z ichiga olgan blokdan chiqilganda MyResource ning dispose() usuli avtomatik ravishda chaqiriladi.

Asinxron yo'q qilinadiganlar

Asinxron yo'q qilinadiganlar uchun obyekt [Symbol.asyncDispose]() usulini belgilaydigan AsyncDisposable interfeysini amalga oshirishi kerak. Bu usul Promise qaytaradi, bu esa asinxron tozalash operatsiyalariga imkon beradi. Bu, ayniqsa, ma'lumotlar bazasi ulanishlari yoki fayl oqimlari kabi asinxron yopishni talab qiladigan resurslar bilan ishlashda foydalidir.

Asinxron yo'q qilinadiganlar batafsil

AsyncDisposable interfeysi quyidagicha aniqlanadi (TypeScript'da):

            interface AsyncDisposable {
  [Symbol.asyncDispose](): Promise;
}

            

              
                Copy
              
            
          

[Symbol.asyncDispose]() usuli barcha zarur asinxron tozalash operatsiyalarini bajarishi va tozalash tugagandan so'ng hal qilinadigan Promise qaytarishi kerak.

Asinxron 'using' deklaratsiyasining amaliy misollari

Keling, 'using' deklaratsiyasini asinxron yo'q qilinadiganlar bilan ishlatishning ba'zi amaliy misollarini ko'rib chiqaylik.

1-misol: Asinxron fayl oqimini boshqarish

Fayldan ma'lumotlarni asinxron tarzda o'qishingiz kerak bo'lgan stsenariyni ko'rib chiqing. Ma'lumotlar o'qib bo'lingandan so'ng, o'qish jarayonida xato yuzaga kelgan taqdirda ham fayl oqimi to'g'ri yopilishini ta'minlash uchun 'using' deklaratsiyasidan foydalanishingiz mumkin.

            import * as fs from 'node:fs/promises';

class AsyncFileStream {
  constructor(private readonly filePath: string) {
    this.fileHandlePromise = fs.open(filePath, 'r');
  }

  private fileHandlePromise: Promise;

  async readData(): Promise {
    const fileHandle = await this.fileHandlePromise;
    const buffer = Buffer.alloc(1024);
    const { bytesRead } = await fileHandle.read(buffer, 0, 1024, 0);
    return buffer.toString('utf8', 0, bytesRead);
  }

  async [Symbol.asyncDispose]() {
    const fileHandle = await this.fileHandlePromise;
    await fileHandle.close();
    console.log("File stream closed.");
  }
}

async function readFileAsync(filePath: string): Promise {
  try {
    using stream = new AsyncFileStream(filePath);
    const data = await stream.readData();
    return data;
  } catch (error) {
    console.error("Error reading file:", error);
    throw error;
  }
}

// Example usage:
async function main() {
  const filePath = 'example.txt';
  // Create a dummy file for the example
  await fs.writeFile(filePath, 'Hello, asynchronous world!\n', { encoding: 'utf8' });

  try {
    const content = await readFileAsync(filePath);
    console.log("File content:", content);
  } catch (error) {
    console.error("Failed to read file.");
  } finally {
    await fs.unlink(filePath); // Clean up the dummy file
  }
}

main();

            

              
                Copy
              
            
          

Bu misolda:

• Biz fayl oqimi mantig'ini o'z ichiga olgan AsyncFileStream sinfini aniqlaymiz.
• [Symbol.asyncDispose]() usuli fayl oqimini asinxron tarzda yopadi.
• readFileAsync funksiyasi xato yuzaga kelishidan qat'i nazar, funksiyadan chiqilganda fayl oqimining yopilishini ta'minlash uchun 'using' deklaratsiyasidan foydalanadi.

2-misol: Asinxron ma'lumotlar bazasi ulanishini boshqarish

Ma'lumotlar bazasi ulanishlarini asinxron boshqarish Node.js ilovalarida keng tarqalgan talabdir. 'using' deklaratsiyasi ma'lumotlar bazasi operatsiyalari paytida xatolar yuzaga kelgan taqdirda ham ulanishlarning to'g'ri yopilishini ta'minlash uchun ishlatilishi mumkin.

            import { Pool, Client } from 'pg';

class AsyncPostgresConnection {
    private client: Client;

    constructor(private connectionString: string) {
        this.client = new Client({ connectionString });
        this.connectionPromise = this.client.connect();
    }

    private connectionPromise: Promise;

    async query(sql: string, params: any[] = []): Promise {
        await this.connectionPromise;
        const result = await this.client.query(sql, params);
        return result.rows;
    }

    async [Symbol.asyncDispose]() {
        await this.connectionPromise; // Ensure connection is established before closing.
        await this.client.end();
        console.log("Database connection closed.");
    }
}

async function fetchDataFromDatabase(connectionString: string): Promise {
    try {
        using connection = new AsyncPostgresConnection(connectionString);
        const data = await connection.query('SELECT * FROM users;');
        return data;
    } catch (error) {
        console.error("Error fetching data:", error);
        throw error;
    }
}

// Example Usage:
async function main() {
    const connectionString = 'postgresql://user:password@host:port/database'; // Replace with your actual connection string

    // Mock database setup (replace with actual setup)
    process.env.PGUSER = 'user';
    process.env.PGPASSWORD = 'password';
    process.env.PGHOST = 'host';
    process.env.PGPORT = '5432';
    process.env.PGDATABASE = 'database';


    const pool = new Pool({ connectionString });

    try {
        await pool.query("CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name VARCHAR(255))");
        await pool.query("INSERT INTO users (name) VALUES ('John Doe'), ('Jane Smith')");

        const data = await fetchDataFromDatabase(connectionString);
        console.log("Data from database:", data);
    } catch (error) {
        console.error("Failed to fetch data.");
    } finally {
        await pool.query("DROP TABLE IF EXISTS users");
        await pool.end();
    }
}

// Execute main function (ensure async context)
// main().catch(console.error);

// You need to replace the connection string with a valid one to run this code.
// This example requires the 'pg' package (npm install pg).

// The main function has been commented out to prevent errors if no PostgreSQL instance is running.
// To run this example, uncomment the main() call and provide valid PostgreSQL credentials and a running database.

            

              
                Copy
              
            
          

Ushbu misoldagi asosiy fikrlar:

• PostgreSQL ma'lumotlar bazasi bilan ishlash uchun pg paketidan foydalanamiz.
• AsyncPostgresConnection sinfi ma'lumotlar bazasi ulanishini boshqaradi.
• [Symbol.asyncDispose]() usuli ma'lumotlar bazasi ulanishini asinxron tarzda yopadi.
• fetchDataFromDatabase funksiyasi ulanishning to'g'ri yopilishini ta'minlash uchun 'using' deklaratsiyasidan foydalanadi.

3-misol: Tashqi xizmat ulanishlarini boshqarish

Ko'pgina ilovalar xabarlar navbatlari yoki kesh tizimlari kabi tashqi xizmatlar bilan o'zaro aloqada bo'ladi. 'using' deklaratsiyasi ushbu xizmatlarga ulanishlar ishlatilgandan keyin to'g'ri yopilishini ta'minlash uchun ishlatilishi mumkin.

Keling, faraziy xabarlar navbati xizmati bilan o'zaro aloqani tasavvur qilaylik:

            class AsyncMessageQueueConnection {
  constructor(private readonly queueUrl: string) {
    this.connectPromise = this.connectToQueue(queueUrl);
  }

  private connectPromise: Promise;
  private queueClient: any; // Replace 'any' with the actual client type

  async connectToQueue(queueUrl: string): Promise {
    // Simulate connecting to the message queue
    return new Promise((resolve) => {
      setTimeout(() => {
        this.queueClient = { // Simulate a client
            sendMessage: async (message:string) => {
                console.log(`Sending message to queue: ${message}`);
                await new Promise(r => setTimeout(r, 100)); // Simulate sending time
                console.log(`Message sent: ${message}`);
            }
        };
        console.log("Connected to message queue.");
        resolve();
      }, 500);
    });
  }

  async sendMessage(message: string): Promise {
    await this.connectPromise;
    if(this.queueClient){
        await this.queueClient.sendMessage(message);
    } else {
        throw new Error("Not connected to message queue")
    }
  }

  async [Symbol.asyncDispose]() {
    await this.connectPromise;
    // Simulate disconnecting from the message queue
    await new Promise((resolve) => {
      setTimeout(() => {
        console.log("Disconnected from message queue.");
        resolve();
      }, 500);
    });
  }
}

async function sendMessagesToQueue(queueUrl: string, messages: string[]): Promise {
  try {
    using connection = new AsyncMessageQueueConnection(queueUrl);
    for (const message of messages) {
      await connection.sendMessage(message);
    }
  } catch (error) {
    console.error("Error sending messages:", error);
    throw error;
  }
}

// Example usage:
async function main() {
  const queueUrl = 'amqp://user:password@host:port/vhost'; // Replace with your actual queue URL
  const messages = ["Message 1", "Message 2", "Message 3"];

  try {
    await sendMessagesToQueue(queueUrl, messages);
    console.log("Messages sent successfully.");
  } catch (error) {
    console.error("Failed to send messages.");
  }
}

// Execute main function (ensure async context)
// main();

// The main function has been commented out to avoid external dependencies.
// To run this example, replace the placeholder code with actual message queue interaction logic.

            

              
                Copy
              
            
          

Bu misolda:

• Biz xabarlar navbatiga ulanishni boshqarish uchun AsyncMessageQueueConnection sinfini aniqlaymiz.
• [Symbol.asyncDispose]() usuli xabarlar navbatidan asinxron uzilishni simulyatsiya qiladi.
• sendMessagesToQueue funksiyasi xabarlar yuborilgandan so'ng ulanishning yopilishini ta'minlash uchun 'using' deklaratsiyasidan foydalanadi.

'using'ni asinxron yo'q qilinadiganlar bilan ishlatishning afzalliklari

'using' deklaratsiyasini asinxron yo'q qilinadiganlar bilan ishlatish bir nechta asosiy afzalliklarni beradi:

• Kafolatlangan resurslarni tozalash: Istisnolar yuzaga kelganda ham resurslarning har doim yo'q qilinishini ta'minlaydi, bu esa xotira sizib chiqishi va resurslarning tugashini oldini oladi.
• Soddalashtirilgan kod: try-finally bloklari bilan bog'liq ortiqcha kodni kamaytiradi, kodni toza va o'qilishi oson qiladi.
• Ishonchlilikni oshirish: Murakkab stsenariylarda ham resurslarning to'g'ri bo'shatilishini kafolatlash orqali asinxron operatsiyalarning ishonchliligini oshiradi.
• Qo'llab-quvvatlash qulayligi: Resurslarni boshqarish deklarativ tarzda amalga oshirilganligi sababli, kodni qo'llab-quvvatlash va tushunish osonroq bo'ladi.
• Yaxshiroq unumdorlik: Resurslarni tezda bo'shatish orqali ilova unumdorligi va kengayishiga hissa qo'shadi.

E'tiborga olinadigan jihatlar va eng yaxshi amaliyotlar

'using' deklaratsiyasi asinxron yo'q qilinadiganlar bilan birgalikda sezilarli afzalliklarni taqdim etsa-da, quyidagi eng yaxshi amaliyotlarni hisobga olish muhim:

• Xatolarni qayta ishlash: Ishlov berilmagan istisnolarning oldini olish uchun [Symbol.asyncDispose]() usulining potentsial xatolarni ohista qayta ishlashini ta'minlang.
• Idempotentlik: [Symbol.asyncDispose]() usulini idempotent qilib loyihalashtiring, ya'ni uni bir necha marta chaqirish salbiy oqibatlarga olib kelmaydi. Bu kutilmagan xatolar yoki qayta urinishlar holatida muhimdir.
• Resurs egaligi: Resurslarning egaligini aniq belgilang va ularni yo'q qilish uchun faqat egasi mas'ul ekanligini ta'minlang.
• TypeScript integratsiyasi: AsyncDisposable interfeysini tatbiq etish va resurslarning to'g'ri yo'q qilinishini ta'minlash uchun TypeScript'ning tur tizimidan foydalaning.
• Polifillar: Agar eski JavaScript muhitlarini nishonga olsangiz, 'using' deklaratsiyasi va Symbol.asyncDispose ramzini qo'llab-quvvatlash uchun polifillardan foydalanishni ko'rib chiqing.

Resurslarni boshqarishga global qarashlar

Resurslarni boshqarish geografik joylashuvidan qat'i nazar, dasturiy ta'minotni ishlab chiqishda universal muammo hisoblanadi. Maxsus texnologiyalar va freymvorklar turlicha bo'lishi mumkin bo'lsa-da, resurslarni ajratish va bo'shatishning asosiy tamoyillari turli mintaqalar va madaniyatlarda bir xil bo'lib qoladi.

Masalan, Yevropa, Shimoliy Amerika, Osiyo va Afrikadagi dasturchilar ma'lumotlar bazasi ulanishlari, fayl oqimlari va tarmoq soketlari bilan ishlashda o'xshash qiyinchiliklarga duch kelishadi. 'using' deklaratsiyasi asinxron yo'q qilinadiganlar bilan birgalikda global miqyosda qo'llanilishi mumkin bo'lgan standartlashtirilgan va samarali yechimni taqdim etadi.

Bundan tashqari, resurslarni boshqarishdagi eng yaxshi amaliyotlarga rioya qilish global auditoriyaga xizmat ko'rsatishi mumkin bo'lgan mustahkam va kengaytiriladigan ilovalarni ishlab chiqishga hissa qo'shadi. Resurslarning to'g'ri bo'shatilishini ta'minlash orqali dasturchilar foydalanuvchining joylashuvidan qat'i nazar, o'z ilovalarining unumdorligi va ishonchliligini oshirishlari mumkin.

Xulosa

JavaScript'ning 'using' deklaratsiyasi, ayniqsa asinxron yo'q qilinadiganlar bilan birgalikda, zamonaviy JavaScript ilovalarida resurslarni xavfsiz va samarali boshqarish uchun kuchli vositadir. Resurslar kerak bo'lmaganda avtomatik ravishda yo'q qilinishini ta'minlash orqali, u xotira sizib chiqishining oldini olishga yordam beradi, kod ishonchliligini oshiradi va ilova unumdorligini yaxshilaydi. Asinxron resurslarni boshqarish bugungi murakkab va asinxron muhitlarda hal qiluvchi ahamiyatga ega va 'using' deklaratsiyasi bu muammoga mustahkam va deklarativ yechim taklif qiladi.

'using' deklaratsiyasini qabul qilish va eng yaxshi amaliyotlarga rioya qilish orqali, dasturchilar global auditoriyaga samarali xizmat ko'rsatishi mumkin bo'lgan yanada ishonchli, kengaytiriladigan va qo'llab-quvvatlanadigan JavaScript ilovalarini yaratishlari mumkin.